package com.atguigu.tingshu.album.service.impl;

import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.service.AlbumAttributeValueService;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.rabbit.constant.MqConst;
import com.atguigu.tingshu.common.rabbit.service.RabbitService;
import com.atguigu.tingshu.common.result.Result;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.AlbumAttributeValueVo;
import com.atguigu.tingshu.vo.album.AlbumInfoVo;
import com.atguigu.tingshu.vo.album.AlbumListVo;
import com.atguigu.tingshu.vo.album.AlbumStatVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Random;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

    @Autowired
    private AlbumInfoMapper albumInfoMapper;
    @Autowired
    private AlbumAttributeValueMapper albumAttributeValueMapper;
    @Autowired
    private AlbumStatMapper albumStatMapper;
    @Autowired
    private AlbumAttributeValueService albumAttributeValueService;
    @Autowired
    private RabbitService rabbitService;

    /**
     * 保存专辑方法
     *
     * @param albumInfoVo
     * @param userId
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveAlbumInfo(AlbumInfoVo albumInfoVo, Long userId) {
        //	1.	album_info
        AlbumInfo albumInfo = new AlbumInfo();
        //	缺少数据，属性赋值：
        BeanUtils.copyProperties(albumInfoVo, albumInfo);
        //	创建专辑的时候，应该知道是谁创建的专辑
        albumInfo.setUserId(userId);
        //	免费试听集数:
        if (!albumInfo.getPayType().equals(SystemConstant.ALBUM_PAY_TYPE_FREE)) {
            //  设置免费试听集数
            albumInfo.setTracksForFree(5);
        }

        //	专辑对应的状态
        albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
        //  执行了保存专辑的操作
        albumInfoMapper.insert(albumInfo);

        //  2.  album_attribute_value
        List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
        if (!CollectionUtils.isEmpty(albumAttributeValueVoList)) {
            //  循环遍历保存数据
            for (AlbumAttributeValueVo albumAttributeValueVo : albumAttributeValueVoList) {
                //  创建对象
                AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
                //  属性拷贝：
                BeanUtils.copyProperties(albumAttributeValueVo, albumAttributeValue);
                //  给专辑属性Id 赋值 @TableId(type = IdType.AUTO) 表示能够获取到主键自增值！
                albumAttributeValue.setAlbumId(albumInfo.getId());
                //  insert into album_attribute_value values(?,?,?,?,?);
                //  insert into album_attribute_value values(?,?,?,?,?);
                //  insert into album_attribute_value values(?,?,?,?,?);
                //  insert into album_attribute_value values(?,?,?,?,?);
                //  insert into album_attribute_value values(?,?,?,?,?);
                albumAttributeValueMapper.insert(albumAttributeValue);
            }
            //  insert into album_attribute_value values(?,?,?,?,?) (?,?,?,?,?) (?,?,?,?,?) (?,?,?,?,?) (?,?,?,?,?);
        }

        //  3. album_stat
        this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_PLAY);
        this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_SUBSCRIBE);
        this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_BROWSE);
        this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_COMMENT);

        // 保存的时候判断专辑字段isopen 是上架还是下架
        // 判断当前专辑字段isopen 是上架还是下架
        if ("1".equals(albumInfo.getIsOpen())) {
            //上架
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM, MqConst.ROUTING_ALBUM_UPPER, albumInfo.getId());
        } else {
            //下架
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM, MqConst.ROUTING_ALBUM_LOWER, albumInfo.getId());
        }
    }

    /**
     * 获取当前用户专辑分页列表
     *
     * @param albumInfoPage
     * @param albumInfoQuery
     * @return
     */
    @Override
    public IPage<AlbumListVo> findUserAlbumPage(Page<AlbumListVo> albumInfoPage, AlbumInfoQuery albumInfoQuery) {
        //	调用mapper 层方法
        return albumInfoMapper.selectUserAlbumPage(albumInfoPage, albumInfoQuery);
    }

    /**
     * 根据专辑id删除专辑数据
     *
     * @param id
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void removeAlbumInfoById(Long id) {
        //  根据专辑Id删除专辑数据; 逻辑删除 is_deleted = 1;
        this.albumInfoMapper.deleteById(id);

        //  album_attribute_value 删除条件：album_id = ?;
        albumAttributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>()
                .eq(AlbumAttributeValue::getAlbumId, id));

        //  album_stat:
        albumStatMapper.delete(new LambdaQueryWrapper<AlbumStat>()
                .eq(AlbumStat::getAlbumId, id));
    }

    /**
     * 根据专辑Id 获取到专辑信息
     *
     * @param id
     * @return
     */
    @Override
    public AlbumInfo getAlbumInfoById(Long id) {
        //  先获取到专辑对象
        AlbumInfo albumInfo = this.getById(id);
        //  获取属性与属性值集合数据
        if (albumInfo != null) {
            List<AlbumAttributeValue> attributeValues = albumAttributeValueMapper.selectList(
                    new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId, id));
            albumInfo.setAlbumAttributeValueVoList(attributeValues);
        }
        //	回显时，需要回显专辑数据信息数据
        return albumInfo;
    }


    /**
     * 修改专辑信息
     *
     * @param id
     * @param albumInfoVo
     */
    @Override
    public void updateAlbumInfo(Long id, AlbumInfoVo albumInfoVo) {
        //  根据专辑Id修改专辑数据;album_info
        //  属性拷贝：
        AlbumInfo albumInfo = new AlbumInfo();
        //  获取属性与属性值的修改内容数据 album_attribute_value
        BeanUtils.copyProperties(albumInfoVo, albumInfo);
        albumInfo.setId(id);
        //  获取属性与属性值的修改内容数据 album_attribute_value
        List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
        //  将原有数据删除，再新增!
        albumAttributeValueMapper.delete(
                new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId, id));
        // 循环遍历保存数据
        if (!CollectionUtils.isEmpty(albumAttributeValueVoList)) {
            for (AlbumAttributeValueVo albumAttributeValueVo : albumAttributeValueVoList) {
                // 创建对象
                AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
                // 属性拷贝
                BeanUtils.copyProperties(albumAttributeValueVo, albumAttributeValue);
                //  给专辑属性Id 赋值 @TableId(type = IdType.AUTO) 表示能够获取到主键自增值！
                albumAttributeValue.setAlbumId(albumInfo.getId());
                albumAttributeValueMapper.insert(albumAttributeValue);
            }
        }

        // 判断当前专辑字段isopen 是上架还是下架
        if ("1".equals(albumInfo.getIsOpen())) {
            //上架
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM, MqConst.ROUTING_ALBUM_UPPER, albumInfo.getId());
        } else {
            //下架
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM, MqConst.ROUTING_ALBUM_LOWER, albumInfo.getId());
        }
    }

    /**
     * 获取到专辑统计信息
     *
     * @param albumId
     * @return
     */
    @Override
    public AlbumStatVo getAlbumStatVoByAlbumId(Long albumId) {
        return albumInfoMapper.selectAlbumStat(albumId);
    }

    /**
     * 根据专辑Id 获取到专辑属性列表
     *
     * @param albumId
     * @return
     */
    @Override
    public Result<List<AlbumAttributeValue>> findAlbumAttributeValueByAlbumId(Long albumId) {
        List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueMapper.selectList(
                new LambdaQueryWrapper<>(AlbumAttributeValue.class)
                        .eq(AlbumAttributeValue::getAlbumId, albumId));
        return Result.ok(albumAttributeValueList);
    }

    /**
     * 初始化统计数据
     *
     * @param albumId
     * @param statType
     */
    private void saveAlbumStat(Long albumId, String statPlay) {
        //  创建对象
        AlbumStat albumStat = new AlbumStat();
        albumStat.setAlbumId(albumId);
        albumStat.setStatType(statPlay);
        albumStat.setStatNum(new Random().nextInt(10000));
        albumStatMapper.insert(albumStat);
    }
}

